node-abort-controller

What is node-abort-controller?

The node-abort-controller package is an implementation of the AbortController interface, which provides a way to abort one or more Web requests as and when desired. It is commonly used to cancel fetch requests or other asynchronous tasks that can be aborted.

What are node-abort-controller's main functionalities?

Creating an AbortController instance

This feature allows you to create a new instance of AbortController. You can then use the 'signal' property to pass the abort signal to functions that accept it.

const AbortController = require('node-abort-controller');
const controller = new AbortController();
const { signal } = controller;

Aborting a fetch request

This code sample demonstrates how to use the AbortController to abort an ongoing fetch request. The fetch request is initiated with the abort signal, and if the request is aborted, it will throw an 'AbortError'.

const fetch = require('node-fetch');
const controller = new AbortController();
const { signal } = controller;

fetch('https://example.com', { signal })
  .then(response => response.json())
  .catch(err => {
    if (err.name === 'AbortError') {
      console.log('Fetch aborted');
    } else {
      console.error('Fetch error:', err);
    }
  });

// Abort the request
controller.abort();

Using AbortController with async/await

This example shows how to use AbortController with async/await syntax. A fetch request is made, and if it is not completed within 5 seconds, the AbortController is used to abort the request.

const fetch = require('node-fetch');
const AbortController = require('node-abort-controller');

async function fetchData(url) {
  const controller = new AbortController();
  const { signal } = controller;
  setTimeout(() => controller.abort(), 5000); // Abort after 5 seconds

  try {
    const response = await fetch(url, { signal });
    return await response.json();
  } catch (err) {
    if (err.name === 'AbortError') {
      console.log('Fetch aborted');
    } else {
      throw err;
    }
  }
}

fetchData('https://example.com').catch(console.error);

Other packages similar to node-abort-controller

abort-controller

The 'abort-controller' package is another implementation of the AbortController interface. It provides similar functionality to 'node-abort-controller' and can be used to abort fetch requests or other asynchronous operations.

p-cancelable

The 'p-cancelable' package allows you to create cancelable promises. Unlike 'node-abort-controller', which implements the standard AbortController interface, 'p-cancelable' provides a custom API for creating and canceling promises.

cancelable-promise

The 'cancelable-promise' package is another alternative that provides the ability to cancel promises. It offers a different API compared to 'node-abort-controller' and is not based on the AbortController interface.

README

node-abort-controller

AbortController Polyfill for Node.JS based on EventEmitter

Usage

import fetch from 'node-fetch'
import AbortController from 'node-abort-controller'

const controller = new AbortController()
const signal = controller.signal

await fetch('https:/www.google.com', { signal })

// Abort after 500ms. Effectively a timeout
setTimeout(() => controller.abort(), 500)

Why would I use this?

You might not need to! Generally speaking, there are three environments your JavaScript code can run in:

• Node
• Modern Browsers (Not Internet Explorer)
• Legacy Browsers (Mostly Internet Explorer)

For modern JS APIs, each environment would ideally get a polyfill:

• only if it needs one
• specific to the platform.

In practice, this is hard. Tooling such as webpack and browserify are great at making sure stuff works out of the box in all environments. But it is quite easy to fail on both points above. In all likelyhood, you end up shipping less than ideal polyfills on platforms that don't even need them. So what is a developer to do? In the case of fetch and AbortController I've done the work for you. This is a guide to that work.

If you are building a ...

Application running in modern browsers:

Congrats! You don't need a library or polyfill at all! Close this tab. Uninstall this package.

Application running in modern browsers AND node (such as a server side rendered JS app):

Use this package and node-fetch. It is minimally what you need.

Application supporting legacy browsers AND NOT node:

Use abort-controller and whatwg-fetch. These are more complete polyfills that will work in all browser environments.

Application supporting legacy browsers AND node:

Use abort-controller and cross-fetch. Same as above, except cross-fetch will polyfill correctly in both the browser and node.js

Library being consumed by other applications and using fetch internally:

Use this package and node-fetch. It is the smallest and least opinionated combination for your end users. Application developers targeting Internet Exploer will need to polyfill AbortController and fetch on their own. But your library won't be forcing unecessary polyfills on developers who only target modern browsers.

Goals

With the above guide in mind, this library has a very specific set of goals:

1. Provide a minimal polyfill in node.js
2. Do not provide a polyfill in any browser environment

This is the ideal for library authors who use fetch and AbortController internally and target both browser and node developers.

Prior Art

Thank you @mysticatea for https://github.com/mysticatea/abort-controller. It is a fantastic AbortController polyfill and ideal for many use cases.